home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Mediterranean / Mediterranean Huge.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  51.4 KB  |  1,635 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Mediterranean Huge.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 9/14/01 10:07a $
  11. // $Revision: 11 $
  12. // $Revision: 11 $Revision: 8
  13. //   Adjusted Angle between team members 
  14. // Revision: 9 
  15. //    Pushed players and outer neutrals toward the map edge
  16. //    increased land, trees, decreased outer neutrals and flat land 
  17. //    Assumes Initial Step = 64 in Mediterranean.rmv
  18. //  Revision: 15 Revised for miniaturization 
  19. //  Revision: 16 Elevation 
  20. //  Revision: 17 Revised # of resources 3 by 3
  21. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  22. //  Revision: 19 General Adjustments
  23. //  Revision: 20c Small Enhancements 
  24. //  Revision: 22 Design Enhancements 
  25. //  Revision: 23 Reduced Resources
  26. //  Revision: 24 Added Chance of steep cliffs 
  27. //  Revision: 26 Evened-out resource distribution 
  28. //  Revision: 28 Moved resources 2 tiles further from Capitol
  29. //  Revision: 29 Added gold and iron to 5+ player maps
  30. //  Revision: 30 Changed convergence from 16,250 to 32,1
  31. //  Revision: 31 Added 1 forage site
  32. //
  33. //////////////////////////////////////////////////////////////////////
  34.  
  35. #if            NOTDEFINED(MEDITERRANEAN_HUGE_RMV)
  36. #define        (MEDITERRANEAN_HUGE_RMV,1)
  37.  
  38. //////////////////////////////////////////////////////////////////////
  39. // Definitions we are required to define for Mediterranean maps
  40. //////////////////////////////////////////////////////////////////////
  41.  
  42. ResourcePlacementLimit (Gold,     8,    13)
  43. ResourcePlacementLimit (Steel,     8,     13)
  44. ResourcePlacementLimit (Stone,     8,     13)
  45. ResourcePlacementLimit (Berry,     7,     11)
  46. ResourcePlacementLimit (Fish,     1,    70)
  47. ResourcePlacementLimit (Tree,     3,     6)
  48. ResourcePlacementLimit (Animal,     7,     15)
  49.  
  50.  
  51. #if Is2Players
  52. //////////////////////////////////////////////////////////////////////
  53. // 2 PLAYERS...
  54. //////////////////////////////////////////////////////////////////////
  55.  
  56. ResourceSeperation    5 
  57.  
  58. //////////////////////////////////////////////////////////////////////
  59. // terrain definitions
  60. #define        (kMinIntElevation,            -8)
  61.  
  62. #if        PERCENT(80)
  63.   #define        (kMaxIntElevation,             10)
  64. #else
  65.   #define        (kMaxIntElevation,            15)
  66. #endif 
  67.  
  68. #define        (kElevationScale,                1)
  69. #define        (kPercentLand,                Between(.94, .94))
  70. #define        (kWaterBorder,                0)
  71. #define        (kHeightMapChaos,                Between(28, 38))
  72.                                             
  73. #define        (kMinimumStartPositionToMapEdge    4)
  74. #define        (kOuterPushFromMapCenter        34)
  75. #define        (kInnerPushFromMapCenter         30)
  76.  
  77. #define        (kConvergentSampleSize,            32) 
  78. #define        (kConvergentThreshold,            100)
  79.  
  80. //////////////////////////////////////////////////////////////////////
  81. // player definitions
  82. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  83. #define        (kPlayerInnerRadius,            0.6)
  84. #define        (kPlayerOuterRadius,            0.99)
  85. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  86. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  87. #define        (kPlayerLandChaos,            0.8)
  88. #define        (kPlayerLandClumps,            1)
  89. #define        (kPlayerFlatChaos,            0.8)
  90. #define        (kPlayerFlatClumps,            1)
  91. #define        (kPlayerTreePercentage,            0.05)
  92.  
  93.  
  94. //////////////////////////////////////////////////////////////////////
  95. // inner neutral definitions
  96. #define        (kNeutralInnerRadius,            0.45)
  97. #define        (kNeutralOuterRadius,            0.45)
  98. #define        (kNeutralOptimalFactor,            0.7)
  99. #define        (kNumInnerNeutrals,            Between(30, 30))
  100. #define        (kInnerNeutralPercentLand,        0.3)
  101. #define        (kInnerNeutralPercentFlat,        Between(.99, .99))
  102. #define        (kInnerNeutralTreePercentage,          0.25)
  103. #define        (kInnerNeutralLandChaos,        0.9)
  104. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  105. #define        (kInnerNeutralFlatChaos,        0.8)
  106. #define        (kInnerNeutralFlatClumps,        1)
  107.  
  108.  
  109. //////////////////////////////////////////////////////////////////////
  110. // outer neutral definitions
  111. #define        (kNumOuterNeutrals,            40)
  112. #define        (kOuterNeutralPercentLand,        0.62)
  113. #define        (kOuterNeutralPercentFlat,        Between(.9, .9))
  114. #define        (kOuterNeutralTreePercentage,          0.12)
  115. #define        (kOuterNeutralLandChaos,        0.8)
  116. #define        (kOuterNeutralLandClumps,        1)
  117. #define        (kOuterNeutralFlatChaos,        0.8)
  118. #define        (kOuterNeutralFlatClumps,        2)
  119.  
  120.  
  121. //////////////////////////////////////////////////////////////////////
  122. // resource definitions
  123. #define        (kMaxResourceElevation,            3)
  124. #define        (kResourceToEdgeDistance,        3)
  125. #define        (kResourceToWaterDistance,        3)
  126.  
  127. #define        (kAnimalPerPlayer,            0)
  128. #define        (kAnimalPerNeutral,            0)
  129.  
  130. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  131.   #define  (kBerryPerPlayer,    1) 
  132.   #define  (kBerryPerNeutral,      6)
  133. #else
  134.   #define  (kBerryPerPlayer,    1)
  135.   #define  (kBerryPerNeutral,      0)
  136. #endif 
  137.  
  138. #define        (kFishPerPlayer,                0)
  139. #define        (kFishPerNeutral,                90)
  140.  
  141. #define        (kGoldPerPlayer,                1)
  142. #define        (kGoldPerNeutral,                8)
  143.  
  144. #define        (kOilPerPlayer,                0)
  145. #define        (kOilPerNeutral,                0)
  146.  
  147. #define        (kSteelPerPlayer,                1)
  148. #define        (kSteelPerNeutral,            8)
  149.  
  150. #define        (kStonePerPlayer,                1)
  151. #define        (kStonePerNeutral,            3)
  152.  
  153. #define        (kTreePerPlayer,                2)
  154. #define        (kTreePerNeutral,                0)
  155.  
  156.  
  157. //////////////////////////////////////////////////////////////////////
  158. // forest definitions
  159. #define        (kForestFreeRadius,            10.0)
  160. #define        (kForestsPerPlayer,            1)
  161. #define        (kForestChaosLevel,            .01)
  162. #define        (kMaxClumpsPerForest,              3)
  163.  
  164.  
  165. #elif Is3Players
  166. //////////////////////////////////////////////////////////////////////
  167. // 3 PLAYERS...
  168. //////////////////////////////////////////////////////////////////////
  169.  
  170. ResourceSeperation    5 
  171.  
  172. //////////////////////////////////////////////////////////////////////
  173. // terrain definitions
  174. #define        (kMinIntElevation,            -8)
  175.  
  176. #if        PERCENT(80)
  177.   #define        (kMaxIntElevation,             10)
  178. #else
  179.   #define        (kMaxIntElevation,            15)
  180. #endif 
  181.  
  182. #define        (kElevationScale,                1)
  183. #define        (kPercentLand,                Between(.92, .92))
  184. #define        (kWaterBorder,                0)
  185. #define        (kHeightMapChaos,                Between(28, 38))
  186.                                             
  187. #define        (kMinimumStartPositionToMapEdge    4)
  188. #define        (kOuterPushFromMapCenter        34)
  189. #define        (kInnerPushFromMapCenter         24)
  190.  
  191. #define        (kConvergentSampleSize,            32) 
  192. #define        (kConvergentThreshold,            1)
  193.  
  194. //////////////////////////////////////////////////////////////////////
  195. // player definitions
  196. #define        (kMaxAngleBetweenTeamMembers,        42.0)
  197. #define        (kPlayerInnerRadius,            0.6)
  198. #define        (kPlayerOuterRadius,            0.99)
  199. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  200. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  201. #define        (kPlayerLandChaos,            0.8)
  202. #define        (kPlayerLandClumps,            1)
  203. #define        (kPlayerFlatChaos,            0.8)
  204. #define        (kPlayerFlatClumps,            1)
  205. #define        (kPlayerTreePercentage,            0.04)
  206.  
  207. //////////////////////////////////////////////////////////////////////
  208. // inner neutral definitions
  209. #define        (kNeutralInnerRadius,            0.43)
  210. #define        (kNeutralOuterRadius,            0.43)
  211. #define        (kNeutralOptimalFactor,            0.7)
  212. #define        (kNumInnerNeutrals,            Between(30, 30))
  213. #define        (kInnerNeutralPercentLand,        0.3)
  214. #define        (kInnerNeutralPercentFlat,        0.9)
  215. #define        (kInnerNeutralTreePercentage,          0.25)
  216. #define        (kInnerNeutralLandChaos,        0.9)
  217. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  218. #define        (kInnerNeutralFlatChaos,        0.8)
  219. #define        (kInnerNeutralFlatClumps,        1)
  220.  
  221.  
  222. //////////////////////////////////////////////////////////////////////
  223. // outer neutral definitions
  224. #define        (kNumOuterNeutrals,            40)
  225. #define        (kOuterNeutralPercentLand,        0.6)
  226. #define        (kOuterNeutralPercentFlat,        0.9)
  227. #define        (kOuterNeutralTreePercentage,          0.12)
  228. #define        (kOuterNeutralLandChaos,        0.8)
  229. #define        (kOuterNeutralLandClumps,        1)
  230. #define        (kOuterNeutralFlatChaos,        0.8)
  231. #define        (kOuterNeutralFlatClumps,        1)
  232.  
  233.  
  234. //////////////////////////////////////////////////////////////////////
  235. // resource definitions
  236. #define        (kMaxResourceElevation,            3)
  237. #define        (kResourceToEdgeDistance,        3)
  238. #define        (kResourceToWaterDistance,        3)
  239.  
  240. #define        (kAnimalPerPlayer,            0)
  241. #define        (kAnimalPerNeutral,            0)
  242.  
  243. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  244.   #define  (kBerryPerPlayer,    1) 
  245.   #define  (kBerryPerNeutral,      9)
  246. #else
  247.   #define  (kBerryPerPlayer,    1)
  248.   #define  (kBerryPerNeutral,      0)
  249. #endif 
  250.  
  251. #define        (kFishPerPlayer,                0)
  252. #define        (kFishPerNeutral,                90)
  253.  
  254. #define        (kGoldPerPlayer,                1)
  255. #define        (kGoldPerNeutral,                11)
  256.  
  257. #define        (kOilPerPlayer,                0)
  258. #define        (kOilPerNeutral,                0)
  259.  
  260. #define        (kSteelPerPlayer,                1)
  261. #define        (kSteelPerNeutral,            11)
  262.  
  263. #define        (kStonePerPlayer,                1)
  264. #define        (kStonePerNeutral,            4)
  265.  
  266. #define        (kTreePerPlayer,                2)
  267. #define        (kTreePerNeutral,                0)
  268.  
  269.  
  270. //////////////////////////////////////////////////////////////////////
  271. // forest definitions
  272. #define        (kForestFreeRadius,            10.0)
  273. #define        (kForestsPerPlayer,            1)
  274. #define        (kForestChaosLevel,            .01)
  275. #define        (kMaxClumpsPerForest,              3)
  276.  
  277.  
  278. #elif Is4Players
  279. //////////////////////////////////////////////////////////////////////
  280. // 4 PLAYERS...
  281. //////////////////////////////////////////////////////////////////////
  282.  
  283. ResourceSeperation    5 
  284.  
  285. //////////////////////////////////////////////////////////////////////
  286. // terrain definitions
  287. #define        (kMinIntElevation,            -8)
  288.  
  289. #if        PERCENT(80)
  290.   #define        (kMaxIntElevation,             10)
  291. #else
  292.   #define        (kMaxIntElevation,            15)
  293. #endif 
  294.  
  295. #define        (kElevationScale,                1)
  296. #define        (kPercentLand,                Between(.9, .9))
  297. #define        (kWaterBorder,                0)
  298. #define        (kHeightMapChaos,                Between(28, 38))
  299.                                             
  300. #define        (kMinimumStartPositionToMapEdge    4)
  301. #define        (kOuterPushFromMapCenter        34)
  302. #define        (kInnerPushFromMapCenter         24)
  303.  
  304. #define        (kConvergentSampleSize,            32) 
  305. #define        (kConvergentThreshold,            1)
  306.  
  307. //////////////////////////////////////////////////////////////////////
  308. // player definitions
  309. #define        (kMaxAngleBetweenTeamMembers,        42.0)
  310. #define        (kPlayerInnerRadius,            0.6)
  311. #define        (kPlayerOuterRadius,            0.99)
  312. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  313. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  314. #define        (kPlayerLandChaos,            0.8)
  315. #define        (kPlayerLandClumps,            1)
  316. #define        (kPlayerFlatChaos,            0.8)
  317. #define        (kPlayerFlatClumps,            1)
  318. #define        (kPlayerTreePercentage,            0.05)
  319.  
  320.  
  321. //////////////////////////////////////////////////////////////////////
  322. // inner neutral definitions
  323. #define        (kNeutralInnerRadius,            0.44)
  324. #define        (kNeutralOuterRadius,            0.44)
  325. #define        (kNeutralOptimalFactor,            0.7)
  326. #define        (kNumInnerNeutrals,            Between(30, 30))
  327. #define        (kInnerNeutralPercentLand,        0.24)
  328. #define        (kInnerNeutralPercentFlat,        0.99)
  329. #define        (kInnerNeutralTreePercentage,          0.25)
  330. #define        (kInnerNeutralLandChaos,        0.9)
  331. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  332. #define        (kInnerNeutralFlatChaos,        0.8)
  333. #define        (kInnerNeutralFlatClumps,        1)
  334.  
  335.  
  336. //////////////////////////////////////////////////////////////////////
  337. // outer neutral definitions
  338. #define        (kNumOuterNeutrals,            40)
  339. #define        (kOuterNeutralPercentLand,        0.50)
  340. #define        (kOuterNeutralPercentFlat,        0.9)
  341. #define        (kOuterNeutralTreePercentage,          0.12)
  342. #define        (kOuterNeutralLandChaos,        0.8)
  343. #define        (kOuterNeutralLandClumps,        1)
  344. #define        (kOuterNeutralFlatChaos,        0.8)
  345. #define        (kOuterNeutralFlatClumps,        1)
  346.  
  347.  
  348. //////////////////////////////////////////////////////////////////////
  349. // resource definitions
  350. #define        (kMaxResourceElevation,            3)
  351. #define        (kResourceToEdgeDistance,        3)
  352. #define        (kResourceToWaterDistance,        3)
  353.  
  354. #define        (kAnimalPerPlayer,            0)
  355. #define        (kAnimalPerNeutral,            0)
  356.  
  357. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  358.   #define  (kBerryPerPlayer,    1) 
  359.   #define  (kBerryPerNeutral,      7)
  360. #else
  361.   #define  (kBerryPerPlayer,    1)
  362.   #define  (kBerryPerNeutral,      0)
  363. #endif 
  364.  
  365. #define        (kFishPerPlayer,                0)
  366. #define        (kFishPerNeutral,                90)
  367.  
  368. #define        (kGoldPerPlayer,                1)
  369. #define        (kGoldPerNeutral,                12)
  370.  
  371. #define        (kOilPerPlayer,                0)
  372. #define        (kOilPerNeutral,                0)
  373.  
  374. #define        (kSteelPerPlayer,                1)
  375. #define        (kSteelPerNeutral,            12)
  376.  
  377. #define        (kStonePerPlayer,                1)
  378. #define        (kStonePerNeutral,            5)
  379.  
  380. #define        (kTreePerPlayer,                2)
  381. #define        (kTreePerNeutral,                1)
  382.  
  383.  
  384. //////////////////////////////////////////////////////////////////////
  385. // forest definitions
  386. #define        (kForestFreeRadius,            10.0)
  387. #define        (kForestsPerPlayer,            1)
  388. #define        (kForestChaosLevel,            .01)
  389. #define        (kMaxClumpsPerForest,              3)
  390.  
  391.  
  392. #elif Is5Players
  393. //////////////////////////////////////////////////////////////////////
  394. // 5 PLAYERS...
  395. //////////////////////////////////////////////////////////////////////
  396.  
  397. ResourceSeperation    5 
  398.  
  399. //////////////////////////////////////////////////////////////////////
  400. // terrain definitions
  401. #define        (kMinIntElevation,            -8)
  402.  
  403. #if        PERCENT(80)
  404.   #define        (kMaxIntElevation,             10)
  405. #else
  406.   #define        (kMaxIntElevation,            15)
  407. #endif 
  408.  
  409. #define        (kElevationScale,                1)
  410. #define        (kPercentLand,                Between(.88, .88))
  411. #define        (kWaterBorder,                0)
  412. #define        (kHeightMapChaos,                Between(28, 38))
  413.                                             
  414. #define        (kMinimumStartPositionToMapEdge    4)
  415. #define        (kOuterPushFromMapCenter        34)
  416. #define        (kInnerPushFromMapCenter         24)
  417.  
  418. #define        (kConvergentSampleSize,            32) 
  419. #define        (kConvergentThreshold,            1)
  420.  
  421. //////////////////////////////////////////////////////////////////////
  422. // player definitions
  423. #define        (kMaxAngleBetweenTeamMembers,        42.0)
  424. #define        (kPlayerInnerRadius,            0.6)
  425. #define        (kPlayerOuterRadius,            0.99)
  426. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  427. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  428. #define        (kPlayerLandChaos,            0.8)
  429. #define        (kPlayerLandClumps,            1)
  430. #define        (kPlayerFlatChaos,            0.8)
  431. #define        (kPlayerFlatClumps,            1)
  432. #define        (kPlayerTreePercentage,            0.045)
  433.  
  434.  
  435. //////////////////////////////////////////////////////////////////////
  436. // inner neutral definitions
  437. #define        (kNeutralInnerRadius,            0.4)
  438. #define        (kNeutralOuterRadius,            0.4)
  439. #define        (kNeutralOptimalFactor,            0.7)
  440. #define        (kNumInnerNeutrals,            Between(30, 30))
  441. #define        (kInnerNeutralPercentLand,        0.25)
  442. #define        (kInnerNeutralPercentFlat,        0.9)
  443. #define        (kInnerNeutralTreePercentage,          0.25)
  444. #define        (kInnerNeutralLandChaos,        0.9)
  445. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  446. #define        (kInnerNeutralFlatChaos,        0.8)
  447. #define        (kInnerNeutralFlatClumps,        1)
  448.  
  449.  
  450. //////////////////////////////////////////////////////////////////////
  451. // outer neutral definitions
  452. #define        (kNumOuterNeutrals,            40)
  453. #define        (kOuterNeutralPercentLand,        0.5)
  454. #define        (kOuterNeutralPercentFlat,        0.9)
  455. #define        (kOuterNeutralTreePercentage,          0.13)
  456. #define        (kOuterNeutralLandChaos,        0.8)
  457. #define        (kOuterNeutralLandClumps,        1)
  458. #define        (kOuterNeutralFlatChaos,        0.8)
  459. #define        (kOuterNeutralFlatClumps,        1)
  460.  
  461.  
  462. //////////////////////////////////////////////////////////////////////
  463. // resource definitions
  464. #define        (kMaxResourceElevation,            3)
  465. #define        (kResourceToEdgeDistance,        3)
  466. #define        (kResourceToWaterDistance,        3)
  467.  
  468. #define        (kAnimalPerPlayer,            0)
  469. #define        (kAnimalPerNeutral,            0)
  470.  
  471. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  472.   #define  (kBerryPerPlayer,    1) 
  473.   #define  (kBerryPerNeutral,      9)
  474. #else
  475.   #define  (kBerryPerPlayer,    1)
  476.   #define  (kBerryPerNeutral,      0)
  477. #endif 
  478.  
  479. #define        (kFishPerPlayer,                0)
  480. #define        (kFishPerNeutral,                90)
  481.  
  482. #define        (kGoldPerPlayer,                1)
  483. #define        (kGoldPerNeutral,                14)
  484.  
  485. #define        (kOilPerPlayer,                0)
  486. #define        (kOilPerNeutral,                0)
  487.  
  488. #define        (kSteelPerPlayer,                1)
  489. #define        (kSteelPerNeutral,            14)
  490.  
  491. #define        (kStonePerPlayer,                1)
  492. #define        (kStonePerNeutral,            6)
  493.  
  494. #define        (kTreePerPlayer,                2)
  495. #define        (kTreePerNeutral,                0)
  496.  
  497.  
  498. //////////////////////////////////////////////////////////////////////
  499. // forest definitions
  500. #define        (kForestFreeRadius,            9.0)
  501. #define        (kForestsPerPlayer,            1)
  502. #define        (kForestChaosLevel,            .01)
  503. #define        (kMaxClumpsPerForest,              3)
  504.  
  505. #elif Is6Players
  506. //////////////////////////////////////////////////////////////////////
  507. // 6 PLAYERS...
  508. //////////////////////////////////////////////////////////////////////
  509.  
  510. ResourceSeperation    5 
  511.  
  512. //////////////////////////////////////////////////////////////////////
  513. // terrain definitions
  514. #define        (kMinIntElevation,            -8)
  515.  
  516. #if        PERCENT(80)
  517.   #define        (kMaxIntElevation,             10)
  518. #else
  519.   #define        (kMaxIntElevation,            15)
  520. #endif 
  521.  
  522. #define        (kElevationScale,                1)
  523. #define        (kPercentLand,                Between(.86, .86))
  524. #define        (kWaterBorder,                0)
  525. #define        (kHeightMapChaos,                Between(28, 38))
  526.                                             
  527. #define        (kMinimumStartPositionToMapEdge    4)
  528. #define        (kOuterPushFromMapCenter        34)
  529. #define        (kInnerPushFromMapCenter         24)        
  530.  
  531. #define        (kConvergentSampleSize,            32) 
  532. #define        (kConvergentThreshold,            1)        
  533.  
  534. //////////////////////////////////////////////////////////////////////
  535. // player definitions
  536. #define        (kMaxAngleBetweenTeamMembers,        42.0)
  537. #define        (kPlayerInnerRadius,            0.6)
  538. #define        (kPlayerOuterRadius,            0.99)
  539. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  540. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  541. #define        (kPlayerLandChaos,            0.8)
  542. #define        (kPlayerLandClumps,            1)
  543. #define        (kPlayerFlatChaos,            0.8)
  544. #define        (kPlayerFlatClumps,            1)
  545. #define        (kPlayerTreePercentage,            0.04)
  546.  
  547.  
  548. //////////////////////////////////////////////////////////////////////
  549. // inner neutral definitions
  550. #define        (kNeutralInnerRadius,            0.39)
  551. #define        (kNeutralOuterRadius,            0.39)
  552. #define        (kNeutralOptimalFactor,            0.7)
  553. #define        (kNumInnerNeutrals,            Between(30, 30))
  554. #define        (kInnerNeutralPercentLand,        0.25)
  555. #define        (kInnerNeutralPercentFlat,        0.9)
  556. #define        (kInnerNeutralTreePercentage,          0.22)
  557. #define        (kInnerNeutralLandChaos,        0.9)
  558. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  559. #define        (kInnerNeutralFlatChaos,        0.8)
  560. #define        (kInnerNeutralFlatClumps,        1)
  561.  
  562.  
  563. //////////////////////////////////////////////////////////////////////
  564. // outer neutral definitions
  565. #define        (kNumOuterNeutrals,            40)
  566. #define        (kOuterNeutralPercentLand,        0.46)
  567. #define        (kOuterNeutralPercentFlat,        0.9)
  568. #define        (kOuterNeutralTreePercentage,          0.14)
  569. #define        (kOuterNeutralLandChaos,        0.8)
  570. #define        (kOuterNeutralLandClumps,        1)
  571. #define        (kOuterNeutralFlatChaos,        0.8)
  572. #define        (kOuterNeutralFlatClumps,        1)
  573.  
  574.  
  575. //////////////////////////////////////////////////////////////////////
  576. // resource definitions
  577. #define        (kMaxResourceElevation,            3)
  578. #define        (kResourceToEdgeDistance,        3)
  579. #define        (kResourceToWaterDistance,        3)
  580.  
  581. #define        (kAnimalPerPlayer,            0)
  582. #define        (kAnimalPerNeutral,            0)
  583.  
  584. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  585.   #define  (kBerryPerPlayer,    2) 
  586.   #define  (kBerryPerNeutral,      0)
  587. #else
  588.   #define  (kBerryPerPlayer,    1)
  589.   #define  (kBerryPerNeutral,      0)
  590. #endif 
  591.  
  592. #define        (kFishPerPlayer,                0)
  593. #define        (kFishPerNeutral,                90)
  594.  
  595. #define        (kGoldPerPlayer,                1)
  596. #define        (kGoldPerNeutral,                18)
  597.  
  598. #define        (kOilPerPlayer,                0)
  599. #define        (kOilPerNeutral,                0)
  600.  
  601. #define        (kSteelPerPlayer,                1)
  602. #define        (kSteelPerNeutral,            18)
  603.  
  604. #define        (kStonePerPlayer,                1)
  605. #define        (kStonePerNeutral,            6)
  606.  
  607. #define        (kTreePerPlayer,                2)
  608. #define        (kTreePerNeutral,                0)
  609.  
  610.  
  611. //////////////////////////////////////////////////////////////////////
  612. // forest definitions
  613. #define        (kForestFreeRadius,            8.0)
  614. #define        (kForestsPerPlayer,            1)
  615. #define        (kForestChaosLevel,            .01)
  616. #define        (kMaxClumpsPerForest,              3)
  617.  
  618.  
  619. #elif Is7Players
  620. //////////////////////////////////////////////////////////////////////
  621. // 7 PLAYERS...
  622. //////////////////////////////////////////////////////////////////////
  623.  
  624. ResourceSeperation    5 
  625.  
  626. //////////////////////////////////////////////////////////////////////
  627. // terrain definitions
  628. #define        (kMinIntElevation,            -8)
  629.  
  630. #if        PERCENT(80)
  631.   #define        (kMaxIntElevation,             10)
  632. #else
  633.   #define        (kMaxIntElevation,            20)
  634. #endif 
  635.  
  636. #define        (kElevationScale,                1)
  637. #define        (kPercentLand,                Between(.84, .84))
  638. #define        (kWaterBorder,                0)
  639. #define        (kHeightMapChaos,                Between(28, 38))
  640.                                             
  641. #define        (kMinimumStartPositionToMapEdge    4)
  642. #define        (kOuterPushFromMapCenter        34)
  643. #define        (kInnerPushFromMapCenter         30)
  644.  
  645. #define        (kConvergentSampleSize,            32) 
  646. #define        (kConvergentThreshold,            1)
  647.  
  648. //////////////////////////////////////////////////////////////////////
  649. // player definitions
  650. #define        (kMaxAngleBetweenTeamMembers,        42.0)
  651. #define        (kPlayerInnerRadius,            0.6)
  652. #define        (kPlayerOuterRadius,            0.99)
  653. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  654. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  655. #define        (kPlayerLandChaos,            0.8)
  656. #define        (kPlayerLandClumps,            1)
  657. #define        (kPlayerFlatChaos,            0.8)
  658. #define        (kPlayerFlatClumps,            1)
  659. #define        (kPlayerTreePercentage,            0.035)
  660.  
  661.  
  662. //////////////////////////////////////////////////////////////////////
  663. // inner neutral definitions
  664. #define        (kNeutralInnerRadius,            0.39)
  665. #define        (kNeutralOuterRadius,            0.39)
  666. #define        (kNeutralOptimalFactor,            0.7)
  667. #define        (kNumInnerNeutrals,            Between(30, 30))
  668. #define        (kInnerNeutralPercentLand,        0.21)
  669. #define        (kInnerNeutralPercentFlat,        0.9)
  670. #define        (kInnerNeutralTreePercentage,          0.25)
  671. #define        (kInnerNeutralLandChaos,        0.9)
  672. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  673. #define        (kInnerNeutralFlatChaos,        0.8)
  674. #define        (kInnerNeutralFlatClumps,        1)
  675.  
  676. //////////////////////////////////////////////////////////////////////
  677. // outer neutral definitions
  678. #define        (kNumOuterNeutrals,            40)
  679. #define        (kOuterNeutralPercentLand,        0.44)
  680. #define        (kOuterNeutralPercentFlat,        0.9)
  681. #define        (kOuterNeutralTreePercentage,          0.14)
  682. #define        (kOuterNeutralLandChaos,        0.8)
  683. #define        (kOuterNeutralLandClumps,        1)
  684. #define        (kOuterNeutralFlatChaos,        0.8)
  685. #define        (kOuterNeutralFlatClumps,        1)
  686.  
  687. //////////////////////////////////////////////////////////////////////
  688. // resource definitions
  689. #define        (kMaxResourceElevation,            3)
  690. #define        (kResourceToEdgeDistance,        3)
  691. #define        (kResourceToWaterDistance,        3)
  692.  
  693. #define        (kAnimalPerPlayer,            0)
  694. #define        (kAnimalPerNeutral,            0)
  695.  
  696. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  697.   #define  (kBerryPerPlayer,    2) 
  698.   #define  (kBerryPerNeutral,      0)
  699. #else
  700.   #define  (kBerryPerPlayer,    1)
  701.   #define  (kBerryPerNeutral,      0)
  702. #endif 
  703.  
  704. #define        (kFishPerPlayer,                0)
  705. #define        (kFishPerNeutral,                90)
  706.  
  707. #define        (kGoldPerPlayer,                1)
  708. #define        (kGoldPerNeutral,                21)
  709.  
  710. #define        (kOilPerPlayer,                0)
  711. #define        (kOilPerNeutral,                0)
  712.  
  713. #define        (kSteelPerPlayer,                1)
  714. #define        (kSteelPerNeutral,            21)
  715.  
  716. #define        (kStonePerPlayer,                1)
  717. #define        (kStonePerNeutral,            7)
  718.  
  719. #define        (kTreePerPlayer,                2)
  720. #define        (kTreePerNeutral,                0)
  721.  
  722.  
  723. //////////////////////////////////////////////////////////////////////
  724. // forest definitions
  725. #define        (kForestFreeRadius,            8.0)
  726. #define        (kForestsPerPlayer,            1)
  727. #define        (kForestChaosLevel,            .01)
  728. #define        (kMaxClumpsPerForest,              3)
  729.  
  730.  
  731. #elif Is8Players
  732. //////////////////////////////////////////////////////////////////////
  733. // 8 PLAYERS...
  734. //////////////////////////////////////////////////////////////////////
  735.  
  736. ResourceSeperation    5 
  737.  
  738. //////////////////////////////////////////////////////////////////////
  739. // terrain definitions
  740. #define        (kMinIntElevation,            -8)
  741.  
  742. #if        PERCENT(80)
  743.   #define        (kMaxIntElevation,             10)
  744. #else
  745.   #define        (kMaxIntElevation,            20)
  746. #endif 
  747.  
  748. #define        (kElevationScale,                1)
  749. #define        (kPercentLand,                Between(.8, .8))
  750. #define        (kWaterBorder,                0)
  751. #define        (kHeightMapChaos,                Between(28, 38))
  752.                                             
  753. #define        (kMinimumStartPositionToMapEdge    4)
  754. #define        (kOuterPushFromMapCenter        34)
  755. #define        (kInnerPushFromMapCenter         24)        
  756.  
  757. #define        (kConvergentSampleSize,            32) 
  758. #define        (kConvergentThreshold,            1)                        
  759.         
  760. //////////////////////////////////////////////////////////////////////
  761. // player definitions
  762. #define        (kMaxAngleBetweenTeamMembers,        42.0)
  763. #define        (kPlayerInnerRadius,            0.6)
  764. #define        (kPlayerOuterRadius,            0.99)
  765. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  766. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  767. #define        (kPlayerLandChaos,            0.8)
  768. #define        (kPlayerLandClumps,            1)
  769. #define        (kPlayerFlatChaos,            0.8)
  770. #define        (kPlayerFlatClumps,            1)
  771. #define        (kPlayerTreePercentage,            0.03)
  772.  
  773.  
  774. //////////////////////////////////////////////////////////////////////
  775. // inner neutral definitions
  776. #define        (kNeutralInnerRadius,            0.45)
  777. #define        (kNeutralOuterRadius,            0.45)
  778. #define        (kNeutralOptimalFactor,            0.7)
  779. #define        (kNumInnerNeutrals,            Between(30, 30))
  780. #define        (kInnerNeutralPercentLand,        0.2)
  781. #define        (kInnerNeutralPercentFlat,        0.9)
  782. #define        (kInnerNeutralTreePercentage,          0.25)
  783. #define        (kInnerNeutralLandChaos,        0.9)
  784. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  785. #define        (kInnerNeutralFlatChaos,        0.8)
  786. #define        (kInnerNeutralFlatClumps,        1)
  787.  
  788.  
  789. //////////////////////////////////////////////////////////////////////
  790. // outer neutral definitions
  791. #define        (kNumOuterNeutrals,            40)
  792. #define        (kOuterNeutralPercentLand,        0.38)
  793. #define        (kOuterNeutralPercentFlat,        0.9)
  794. #define        (kOuterNeutralTreePercentage,          0.15)
  795. #define        (kOuterNeutralLandChaos,        0.8)
  796. #define        (kOuterNeutralLandClumps,        1)
  797. #define        (kOuterNeutralFlatChaos,        0.8)
  798. #define        (kOuterNeutralFlatClumps,        1)
  799.  
  800.  
  801. //////////////////////////////////////////////////////////////////////
  802. // resource definitions
  803. #define        (kMaxResourceElevation,            3)
  804. #define        (kResourceToEdgeDistance,        3)
  805. #define        (kResourceToWaterDistance,        3)
  806.  
  807. #define        (kAnimalPerPlayer,            0)
  808. #define        (kAnimalPerNeutral,            0)
  809.  
  810. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  811.   #define  (kBerryPerPlayer,    2) 
  812.   #define  (kBerryPerNeutral,      0)
  813. #else
  814.   #define  (kBerryPerPlayer,    1)
  815.   #define  (kBerryPerNeutral,      0)
  816. #endif 
  817.  
  818. #define        (kFishPerPlayer,                0)
  819. #define        (kFishPerNeutral,                90)
  820.  
  821. #define        (kGoldPerPlayer,                1)
  822. #define        (kGoldPerNeutral,                24)
  823.  
  824. #define        (kOilPerPlayer,                0)
  825. #define        (kOilPerNeutral,                0)
  826.  
  827. #define        (kSteelPerPlayer,                1)
  828. #define        (kSteelPerNeutral,            24)
  829.  
  830. #define        (kStonePerPlayer,                1)
  831. #define        (kStonePerNeutral,            7)
  832.  
  833. #define        (kTreePerPlayer,                2)
  834. #define        (kTreePerNeutral,                0)
  835.  
  836.  
  837. //////////////////////////////////////////////////////////////////////
  838. // forest definitions
  839. #define        (kForestFreeRadius,            8.0)
  840. #define        (kForestsPerPlayer,            1)
  841. #define        (kForestChaosLevel,            .01)
  842. #define        (kMaxClumpsPerForest,              3)
  843.  
  844.  
  845. #elif Is9Players
  846. //////////////////////////////////////////////////////////////////////
  847. // 9 PLAYERS...
  848. //////////////////////////////////////////////////////////////////////
  849.  
  850. //////////////////////////////////////////////////////////////////////
  851. // terrain definitions
  852. #define        (kMinIntElevation,            -8)
  853. #define        (kMaxIntElevation,            10)
  854. #define        (kElevationScale,                1)
  855. #define        (kPercentLand,                Between(.72, .72))
  856. #define        (kWaterBorder,                0)
  857. #define        (kHeightMapChaos,                Between(12, 24))
  858.                                             
  859. #define        (kMinimumStartPositionToMapEdge    4)
  860. #define        (kOuterPushFromMapCenter        34)
  861. #define        (kInnerPushFromMapCenter         24)                                
  862.         
  863. //////////////////////////////////////////////////////////////////////
  864. // player definitions
  865. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  866. #define        (kPlayerInnerRadius,            0.6)
  867. #define        (kPlayerOuterRadius,            0.99)
  868. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  869. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  870. #define        (kPlayerLandChaos,            0.8)
  871. #define        (kPlayerLandClumps,            1)
  872. #define        (kPlayerFlatChaos,            0.8)
  873. #define        (kPlayerFlatClumps,            2)
  874. #define        (kPlayerTreePercentage,            0.03)
  875.  
  876.  
  877. //////////////////////////////////////////////////////////////////////
  878. // inner neutral definitions
  879. #define        (kNeutralInnerRadius,            0.5)
  880. #define        (kNeutralOuterRadius,            0.5)
  881. #define        (kNeutralOptimalFactor,            0.7)
  882. #define        (kNumInnerNeutrals,            Between(6, 6))
  883. #define        (kInnerNeutralPercentLand,        0.11)
  884. #define        (kInnerNeutralPercentFlat,        0.9)
  885. #define        (kInnerNeutralTreePercentage,          0.12)
  886. #define        (kInnerNeutralLandChaos,        0.9)
  887. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  888. #define        (kInnerNeutralFlatChaos,        0.8)
  889. #define        (kInnerNeutralFlatClumps,        1)
  890.  
  891.  
  892. //////////////////////////////////////////////////////////////////////
  893. // outer neutral definitions
  894. #define        (kNumOuterNeutrals,            36)
  895. #define        (kOuterNeutralPercentLand,        0.73)
  896. #define        (kOuterNeutralPercentFlat,        0.9)
  897. #define        (kOuterNeutralTreePercentage,          0.07)
  898. #define        (kOuterNeutralLandChaos,        0.8)
  899. #define        (kOuterNeutralLandClumps,        2)
  900. #define        (kOuterNeutralFlatChaos,        0.8)
  901. #define        (kOuterNeutralFlatClumps,        1)
  902.  
  903.  
  904. //////////////////////////////////////////////////////////////////////
  905. // resource definitions
  906. #define        (kMaxResourceElevation,            3)
  907. #define        (kResourceToEdgeDistance,        3)
  908. #define        (kResourceToWaterDistance,        3)
  909.  
  910. #define        (kAnimalPerPlayer,            0)
  911. #define        (kAnimalPerNeutral,            0)
  912.  
  913. #define        (kBerryPerPlayer,                1)
  914. #define        (kBerryPerNeutral,            0)
  915.  
  916. #define        (kFishPerPlayer,                0)
  917. #define        (kFishPerNeutral,                80)
  918.  
  919. #define        (kGoldPerPlayer,                1)
  920. #define        (kGoldPerNeutral,                13)
  921.  
  922. #define        (kOilPerPlayer,                0)
  923. #define        (kOilPerNeutral,                0)
  924.  
  925. #define        (kSteelPerPlayer,                1)
  926. #define        (kSteelPerNeutral,            13)
  927.  
  928. #define        (kStonePerPlayer,                1)
  929. #define        (kStonePerNeutral,            7)
  930.  
  931. #define        (kTreePerPlayer,                0)
  932. #define        (kTreePerNeutral,                0)
  933.  
  934.  
  935. //////////////////////////////////////////////////////////////////////
  936. // forest definitions
  937. #define        (kForestFreeRadius,            9.0)
  938. #define        (kForestsPerPlayer,            2)
  939. #define        (kForestChaosLevel,            .01)
  940. #define        (kMaxClumpsPerForest,              3)
  941.  
  942.  
  943. #elif Is10Players
  944. //////////////////////////////////////////////////////////////////////
  945. // 10 PLAYERS...
  946. //////////////////////////////////////////////////////////////////////
  947.  
  948. //////////////////////////////////////////////////////////////////////
  949. // terrain definitions
  950. #define        (kMinIntElevation,            -10)
  951. #define        (kMaxIntElevation,            12)
  952. #define        (kElevationScale,                0.99)
  953. #define        (kPercentLand,                Between(.92, .92))
  954. #define        (kWaterBorder,                0)
  955. #define        (kHeightMapChaos,                Between(10, 30))
  956.  
  957. #define        (kMinimumStartPositionToMapEdge    4)
  958. #define        (kOuterPushFromMapCenter        34)
  959. #define        (kInnerPushFromMapCenter         0)                                    
  960.         
  961. //////////////////////////////////////////////////////////////////////
  962. // player definitions
  963. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  964. #define        (kPlayerInnerRadius,            0.6)
  965. #define        (kPlayerOuterRadius,            0.99)
  966. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  967. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  968. #define        (kPlayerLandChaos,            0.8)
  969. #define        (kPlayerLandClumps,            1)
  970. #define        (kPlayerFlatChaos,            0.8)
  971. #define        (kPlayerFlatClumps,            2)
  972. #define        (kPlayerTreePercentage,            0.03)
  973.  
  974.  
  975. //////////////////////////////////////////////////////////////////////
  976. // inner neutral definitions
  977. #define        (kNeutralInnerRadius,            0.5)
  978. #define        (kNeutralOuterRadius,            0.5)
  979. #define        (kNeutralOptimalFactor,            0.7)
  980. #define        (kNumInnerNeutrals,            Between(6, 6))
  981. #define        (kInnerNeutralPercentLand,        0.11)
  982. #define        (kInnerNeutralPercentFlat,        0.9)
  983. #define        (kInnerNeutralTreePercentage,          0.12)
  984. #define        (kInnerNeutralLandChaos,        0.9)
  985. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  986. #define        (kInnerNeutralFlatChaos,        0.8)
  987. #define        (kInnerNeutralFlatClumps,        1)
  988.  
  989.  
  990. //////////////////////////////////////////////////////////////////////
  991. // outer neutral definitions
  992. #define        (kNumOuterNeutrals,            36)
  993. #define        (kOuterNeutralPercentLand,        0.73)
  994. #define        (kOuterNeutralPercentFlat,        0.9)
  995. #define        (kOuterNeutralTreePercentage,          0.07)
  996. #define        (kOuterNeutralLandChaos,        0.8)
  997. #define        (kOuterNeutralLandClumps,        2)
  998. #define        (kOuterNeutralFlatChaos,        0.8)
  999. #define        (kOuterNeutralFlatClumps,        1)
  1000.  
  1001.  
  1002. //////////////////////////////////////////////////////////////////////
  1003. // resource definitions
  1004. #define        (kMaxResourceElevation,            3)
  1005. #define        (kResourceToEdgeDistance,        3)
  1006. #define        (kResourceToWaterDistance,        3)
  1007.  
  1008. #define        (kAnimalPerPlayer,            0)
  1009. #define        (kAnimalPerNeutral,            0)
  1010.  
  1011. #define        (kBerryPerPlayer,                1)
  1012. #define        (kBerryPerNeutral,            0)
  1013.  
  1014. #define        (kFishPerPlayer,                0)
  1015. #define        (kFishPerNeutral,                80)
  1016.  
  1017. #define        (kGoldPerPlayer,                1)
  1018. #define        (kGoldPerNeutral,                13)
  1019.  
  1020. #define        (kOilPerPlayer,                0)
  1021. #define        (kOilPerNeutral,                0)
  1022.  
  1023. #define        (kSteelPerPlayer,                1)
  1024. #define        (kSteelPerNeutral,            13)
  1025.  
  1026. #define        (kStonePerPlayer,                1)
  1027. #define        (kStonePerNeutral,            7)
  1028.  
  1029. #define        (kTreePerPlayer,                0)
  1030. #define        (kTreePerNeutral,                0)
  1031.  
  1032.  
  1033. //////////////////////////////////////////////////////////////////////
  1034. // forest definitions
  1035. #define        (kForestFreeRadius,            9.0)
  1036. #define        (kForestsPerPlayer,            2)
  1037. #define        (kForestChaosLevel,            0.9)
  1038. #define        (kMaxClumpsPerForest,              2)
  1039.  
  1040.  
  1041. #elif Is11Players
  1042. //////////////////////////////////////////////////////////////////////
  1043. // 11 PLAYERS...
  1044. //////////////////////////////////////////////////////////////////////
  1045.  
  1046. //////////////////////////////////////////////////////////////////////
  1047. // terrain definitions
  1048. #define        (kMinIntElevation,            -10)
  1049. #define        (kMaxIntElevation,            12)
  1050. #define        (kElevationScale,                0.99)
  1051. #define        (kPercentLand,                Between(.92, .92))
  1052. #define        (kWaterBorder,                0)
  1053. #define        (kHeightMapChaos,                Between(10, 30))
  1054.  
  1055. #define        (kMinimumStartPositionToMapEdge    4)
  1056. #define        (kOuterPushFromMapCenter        34)
  1057. #define        (kInnerPushFromMapCenter         0)                                    
  1058.         
  1059. //////////////////////////////////////////////////////////////////////
  1060. // player definitions
  1061. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  1062. #define        (kPlayerInnerRadius,            0.6)
  1063. #define        (kPlayerOuterRadius,            0.99)
  1064. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1065. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  1066. #define        (kPlayerLandChaos,            0.8)
  1067. #define        (kPlayerLandClumps,            1)
  1068. #define        (kPlayerFlatChaos,            0.8)
  1069. #define        (kPlayerFlatClumps,            2)
  1070. #define        (kPlayerTreePercentage,            0.03)
  1071.  
  1072.  
  1073. //////////////////////////////////////////////////////////////////////
  1074. // inner neutral definitions
  1075. #define        (kNeutralInnerRadius,            0.5)
  1076. #define        (kNeutralOuterRadius,            0.5)
  1077. #define        (kNeutralOptimalFactor,            0.7)
  1078. #define        (kNumInnerNeutrals,            Between(6, 6))
  1079. #define        (kInnerNeutralPercentLand,        0.11)
  1080. #define        (kInnerNeutralPercentFlat,        0.9)
  1081. #define        (kInnerNeutralTreePercentage,          0.12)
  1082. #define        (kInnerNeutralLandChaos,        0.9)
  1083. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1084. #define        (kInnerNeutralFlatChaos,        0.8)
  1085. #define        (kInnerNeutralFlatClumps,        1)
  1086.  
  1087.  
  1088. //////////////////////////////////////////////////////////////////////
  1089. // outer neutral definitions
  1090. #define        (kNumOuterNeutrals,            36)
  1091. #define        (kOuterNeutralPercentLand,        0.73)
  1092. #define        (kOuterNeutralPercentFlat,        0.9)
  1093. #define        (kOuterNeutralTreePercentage,          0.07)
  1094. #define        (kOuterNeutralLandChaos,        0.8)
  1095. #define        (kOuterNeutralLandClumps,        2)
  1096. #define        (kOuterNeutralFlatChaos,        0.8)
  1097. #define        (kOuterNeutralFlatClumps,        1)
  1098.  
  1099.  
  1100. //////////////////////////////////////////////////////////////////////
  1101. // resource definitions
  1102. #define        (kMaxResourceElevation,            3)
  1103. #define        (kResourceToEdgeDistance,        3)
  1104. #define        (kResourceToWaterDistance,        3)
  1105.  
  1106. #define        (kAnimalPerPlayer,            0)
  1107. #define        (kAnimalPerNeutral,            0)
  1108.  
  1109. #define        (kBerryPerPlayer,                1)
  1110. #define        (kBerryPerNeutral,            0)
  1111.  
  1112. #define        (kFishPerPlayer,                0)
  1113. #define        (kFishPerNeutral,                80)
  1114.  
  1115. #define        (kGoldPerPlayer,                1)
  1116. #define        (kGoldPerNeutral,                13)
  1117.  
  1118. #define        (kOilPerPlayer,                0)
  1119. #define        (kOilPerNeutral,                0)
  1120.  
  1121. #define        (kSteelPerPlayer,                1)
  1122. #define        (kSteelPerNeutral,            13)
  1123.  
  1124. #define        (kStonePerPlayer,                1)
  1125. #define        (kStonePerNeutral,            7)
  1126.  
  1127. #define        (kTreePerPlayer,                0)
  1128. #define        (kTreePerNeutral,                0)
  1129.  
  1130.  
  1131. //////////////////////////////////////////////////////////////////////
  1132. // forest definitions
  1133. #define        (kForestFreeRadius,            9.0)
  1134. #define        (kForestsPerPlayer,            2)
  1135. #define        (kForestChaosLevel,            0.9)
  1136. #define        (kMaxClumpsPerForest,              2)
  1137.  
  1138.  
  1139. #elif Is12Players
  1140. //////////////////////////////////////////////////////////////////////
  1141. // 12 PLAYERS...
  1142. //////////////////////////////////////////////////////////////////////
  1143.  
  1144. //////////////////////////////////////////////////////////////////////
  1145. // terrain definitions
  1146. #define        (kMinIntElevation,            -10)
  1147. #define        (kMaxIntElevation,            12)
  1148. #define        (kElevationScale,                0.99)
  1149. #define        (kPercentLand,                Between(.92, .92))
  1150. #define        (kWaterBorder,                0)
  1151. #define        (kHeightMapChaos,                Between(10, 30))
  1152.  
  1153. #define        (kMinimumStartPositionToMapEdge    4)
  1154. #define        (kOuterPushFromMapCenter        34)
  1155. #define        (kInnerPushFromMapCenter         0)                                    
  1156.         
  1157. //////////////////////////////////////////////////////////////////////
  1158. // player definitions
  1159. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  1160. #define        (kPlayerInnerRadius,            0.6)
  1161. #define        (kPlayerOuterRadius,            0.99)
  1162. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1163. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  1164. #define        (kPlayerLandChaos,            0.8)
  1165. #define        (kPlayerLandClumps,            1)
  1166. #define        (kPlayerFlatChaos,            0.8)
  1167. #define        (kPlayerFlatClumps,            2)
  1168. #define        (kPlayerTreePercentage,            0.03)
  1169.  
  1170.  
  1171. //////////////////////////////////////////////////////////////////////
  1172. // inner neutral definitions
  1173. #define        (kNeutralInnerRadius,            0.5)
  1174. #define        (kNeutralOuterRadius,            0.5)
  1175. #define        (kNeutralOptimalFactor,            0.7)
  1176. #define        (kNumInnerNeutrals,            Between(6, 6))
  1177. #define        (kInnerNeutralPercentLand,        0.11)
  1178. #define        (kInnerNeutralPercentFlat,        0.9)
  1179. #define        (kInnerNeutralTreePercentage,          0.12)
  1180. #define        (kInnerNeutralLandChaos,        0.9)
  1181. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1182. #define        (kInnerNeutralFlatChaos,        0.8)
  1183. #define        (kInnerNeutralFlatClumps,        1)
  1184.  
  1185.  
  1186. //////////////////////////////////////////////////////////////////////
  1187. // outer neutral definitions
  1188. #define        (kNumOuterNeutrals,            36)
  1189. #define        (kOuterNeutralPercentLand,        0.73)
  1190. #define        (kOuterNeutralPercentFlat,        0.9)
  1191. #define        (kOuterNeutralTreePercentage,          0.07)
  1192. #define        (kOuterNeutralLandChaos,        0.8)
  1193. #define        (kOuterNeutralLandClumps,        2)
  1194. #define        (kOuterNeutralFlatChaos,        0.8)
  1195. #define        (kOuterNeutralFlatClumps,        1)
  1196.  
  1197.  
  1198. //////////////////////////////////////////////////////////////////////
  1199. // resource definitions
  1200. #define        (kMaxResourceElevation,            3)
  1201. #define        (kResourceToEdgeDistance,        3)
  1202. #define        (kResourceToWaterDistance,        3)
  1203.  
  1204. #define        (kAnimalPerPlayer,            0)
  1205. #define        (kAnimalPerNeutral,            0)
  1206.  
  1207. #define        (kBerryPerPlayer,                1)
  1208. #define        (kBerryPerNeutral,            0)
  1209.  
  1210. #define        (kFishPerPlayer,                0)
  1211. #define        (kFishPerNeutral,                80)
  1212.  
  1213. #define        (kGoldPerPlayer,                1)
  1214. #define        (kGoldPerNeutral,                13)
  1215.  
  1216. #define        (kOilPerPlayer,                0)
  1217. #define        (kOilPerNeutral,                0)
  1218.  
  1219. #define        (kSteelPerPlayer,                1)
  1220. #define        (kSteelPerNeutral,            13)
  1221.  
  1222. #define        (kStonePerPlayer,                1)
  1223. #define        (kStonePerNeutral,            7)
  1224.  
  1225. #define        (kTreePerPlayer,                0)
  1226. #define        (kTreePerNeutral,                0)
  1227.  
  1228.  
  1229. //////////////////////////////////////////////////////////////////////
  1230. // forest definitions
  1231. #define        (kForestFreeRadius,            9.0)
  1232. #define        (kForestsPerPlayer,            2)
  1233. #define        (kForestChaosLevel,            0.9)
  1234. #define        (kMaxClumpsPerForest,              2)
  1235.  
  1236.  
  1237. #elif Is13Players
  1238. //////////////////////////////////////////////////////////////////////
  1239. // 13 PLAYERS...
  1240. //////////////////////////////////////////////////////////////////////
  1241.  
  1242. //////////////////////////////////////////////////////////////////////
  1243. // terrain definitions
  1244. #define        (kMinIntElevation,            -10)
  1245. #define        (kMaxIntElevation,            12)
  1246. #define        (kElevationScale,                0.99)
  1247. #define        (kPercentLand,                Between(.92, .92))
  1248. #define        (kWaterBorder,                0)
  1249. #define        (kHeightMapChaos,                Between(10, 30))
  1250.  
  1251. #define        (kMinimumStartPositionToMapEdge    4)
  1252. #define        (kOuterPushFromMapCenter        34)
  1253. #define        (kInnerPushFromMapCenter         0)                                    
  1254.         
  1255. //////////////////////////////////////////////////////////////////////
  1256. // player definitions
  1257. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  1258. #define        (kPlayerInnerRadius,            0.6)
  1259. #define        (kPlayerOuterRadius,            0.99)
  1260. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1261. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  1262. #define        (kPlayerLandChaos,            0.8)
  1263. #define        (kPlayerLandClumps,            1)
  1264. #define        (kPlayerFlatChaos,            0.8)
  1265. #define        (kPlayerFlatClumps,            2)
  1266. #define        (kPlayerTreePercentage,            0.03)
  1267.  
  1268.  
  1269. //////////////////////////////////////////////////////////////////////
  1270. // inner neutral definitions
  1271. #define        (kNeutralInnerRadius,            0.5)
  1272. #define        (kNeutralOuterRadius,            0.5)
  1273. #define        (kNeutralOptimalFactor,            0.7)
  1274. #define        (kNumInnerNeutrals,            Between(6, 6))
  1275. #define        (kInnerNeutralPercentLand,        0.11)
  1276. #define        (kInnerNeutralPercentFlat,        0.9)
  1277. #define        (kInnerNeutralTreePercentage,          0.12)
  1278. #define        (kInnerNeutralLandChaos,        0.9)
  1279. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1280. #define        (kInnerNeutralFlatChaos,        0.8)
  1281. #define        (kInnerNeutralFlatClumps,        1)
  1282.  
  1283.  
  1284. //////////////////////////////////////////////////////////////////////
  1285. // outer neutral definitions
  1286. #define        (kNumOuterNeutrals,            36)
  1287. #define        (kOuterNeutralPercentLand,        0.73)
  1288. #define        (kOuterNeutralPercentFlat,        0.9)
  1289. #define        (kOuterNeutralTreePercentage,          0.07)
  1290. #define        (kOuterNeutralLandChaos,        0.8)
  1291. #define        (kOuterNeutralLandClumps,        2)
  1292. #define        (kOuterNeutralFlatChaos,        0.8)
  1293. #define        (kOuterNeutralFlatClumps,        1)
  1294.  
  1295.  
  1296. //////////////////////////////////////////////////////////////////////
  1297. // resource definitions
  1298. #define        (kMaxResourceElevation,            3)
  1299. #define        (kResourceToEdgeDistance,        3)
  1300. #define        (kResourceToWaterDistance,        3)
  1301.  
  1302. #define        (kAnimalPerPlayer,            0)
  1303. #define        (kAnimalPerNeutral,            0)
  1304.  
  1305. #define        (kBerryPerPlayer,                1)
  1306. #define        (kBerryPerNeutral,            0)
  1307.  
  1308. #define        (kFishPerPlayer,                0)
  1309. #define        (kFishPerNeutral,                80)
  1310.  
  1311. #define        (kGoldPerPlayer,                1)
  1312. #define        (kGoldPerNeutral,                13)
  1313.  
  1314. #define        (kOilPerPlayer,                0)
  1315. #define        (kOilPerNeutral,                0)
  1316.  
  1317. #define        (kSteelPerPlayer,                1)
  1318. #define        (kSteelPerNeutral,            13)
  1319.  
  1320. #define        (kStonePerPlayer,                1)
  1321. #define        (kStonePerNeutral,            7)
  1322.  
  1323. #define        (kTreePerPlayer,                0)
  1324. #define        (kTreePerNeutral,                0)
  1325.  
  1326.  
  1327. //////////////////////////////////////////////////////////////////////
  1328. // forest definitions
  1329. #define        (kForestFreeRadius,            9.0)
  1330. #define        (kForestsPerPlayer,            2)
  1331. #define        (kForestChaosLevel,            0.9)
  1332. #define        (kMaxClumpsPerForest,              2)
  1333.  
  1334.  
  1335. #elif Is14Players
  1336. //////////////////////////////////////////////////////////////////////
  1337. // 14 PLAYERS...
  1338. //////////////////////////////////////////////////////////////////////
  1339.  
  1340. //////////////////////////////////////////////////////////////////////
  1341. // terrain definitions
  1342. #define        (kMinIntElevation,            -10)
  1343. #define        (kMaxIntElevation,            12)
  1344. #define        (kElevationScale,                0.99)
  1345. #define        (kPercentLand,                Between(.92, .92))
  1346. #define        (kWaterBorder,                0)
  1347. #define        (kHeightMapChaos,                Between(10, 30))
  1348.  
  1349. #define        (kMinimumStartPositionToMapEdge    4)
  1350. #define        (kOuterPushFromMapCenter        34)
  1351. #define        (kInnerPushFromMapCenter         0)                                    
  1352.         
  1353. //////////////////////////////////////////////////////////////////////
  1354. // player definitions
  1355. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  1356. #define        (kPlayerInnerRadius,            0.6)
  1357. #define        (kPlayerOuterRadius,            0.99)
  1358. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1359. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  1360. #define        (kPlayerLandChaos,            0.8)
  1361. #define        (kPlayerLandClumps,            1)
  1362. #define        (kPlayerFlatChaos,            0.8)
  1363. #define        (kPlayerFlatClumps,            2)
  1364. #define        (kPlayerTreePercentage,            0.03)
  1365.  
  1366.  
  1367. //////////////////////////////////////////////////////////////////////
  1368. // inner neutral definitions
  1369. #define        (kNeutralInnerRadius,            0.5)
  1370. #define        (kNeutralOuterRadius,            0.5)
  1371. #define        (kNeutralOptimalFactor,            0.7)
  1372. #define        (kNumInnerNeutrals,            Between(6, 6))
  1373. #define        (kInnerNeutralPercentLand,        0.11)
  1374. #define        (kInnerNeutralPercentFlat,        0.9)
  1375. #define        (kInnerNeutralTreePercentage,          0.12)
  1376. #define        (kInnerNeutralLandChaos,        0.9)
  1377. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1378. #define        (kInnerNeutralFlatChaos,        0.8)
  1379. #define        (kInnerNeutralFlatClumps,        1)
  1380.  
  1381.  
  1382. //////////////////////////////////////////////////////////////////////
  1383. // outer neutral definitions
  1384. #define        (kNumOuterNeutrals,            36)
  1385. #define        (kOuterNeutralPercentLand,        0.73)
  1386. #define        (kOuterNeutralPercentFlat,        0.9)
  1387. #define        (kOuterNeutralTreePercentage,          0.07)
  1388. #define        (kOuterNeutralLandChaos,        0.8)
  1389. #define        (kOuterNeutralLandClumps,        2)
  1390. #define        (kOuterNeutralFlatChaos,        0.8)
  1391. #define        (kOuterNeutralFlatClumps,        1)
  1392.  
  1393.  
  1394. //////////////////////////////////////////////////////////////////////
  1395. // resource definitions
  1396. #define        (kMaxResourceElevation,            3)
  1397. #define        (kResourceToEdgeDistance,        3)
  1398. #define        (kResourceToWaterDistance,        3)
  1399.  
  1400. #define        (kAnimalPerPlayer,            0)
  1401. #define        (kAnimalPerNeutral,            0)
  1402.  
  1403. #define        (kBerryPerPlayer,                1)
  1404. #define        (kBerryPerNeutral,            0)
  1405.  
  1406. #define        (kFishPerPlayer,                0)
  1407. #define        (kFishPerNeutral,                80)
  1408.  
  1409. #define        (kGoldPerPlayer,                1)
  1410. #define        (kGoldPerNeutral,                13)
  1411.  
  1412. #define        (kOilPerPlayer,                0)
  1413. #define        (kOilPerNeutral,                0)
  1414.  
  1415. #define        (kSteelPerPlayer,                1)
  1416. #define        (kSteelPerNeutral,            13)
  1417.  
  1418. #define        (kStonePerPlayer,                1)
  1419. #define        (kStonePerNeutral,            7)
  1420.  
  1421. #define        (kTreePerPlayer,                0)
  1422. #define        (kTreePerNeutral,                0)
  1423.  
  1424.  
  1425. //////////////////////////////////////////////////////////////////////
  1426. // forest definitions
  1427. #define        (kForestFreeRadius,            9.0)
  1428. #define        (kForestsPerPlayer,            2)
  1429. #define        (kForestChaosLevel,            0.9)
  1430. #define        (kMaxClumpsPerForest,              2)
  1431.  
  1432.  
  1433. #elif Is15Players
  1434. //////////////////////////////////////////////////////////////////////
  1435. // 15 PLAYERS...
  1436. //////////////////////////////////////////////////////////////////////
  1437.  
  1438. //////////////////////////////////////////////////////////////////////
  1439. // terrain definitions
  1440. #define        (kMinIntElevation,            -10)
  1441. #define        (kMaxIntElevation,            12)
  1442. #define        (kElevationScale,                0.99)
  1443. #define        (kPercentLand,                Between(.92, .92))
  1444. #define        (kWaterBorder,                0)
  1445. #define        (kHeightMapChaos,                Between(10, 30))
  1446.  
  1447. #define        (kMinimumStartPositionToMapEdge    4)
  1448. #define        (kOuterPushFromMapCenter        34)
  1449. #define        (kInnerPushFromMapCenter         0)                                    
  1450.         
  1451. //////////////////////////////////////////////////////////////////////
  1452. // player definitions
  1453. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  1454. #define        (kPlayerInnerRadius,            0.6)
  1455. #define        (kPlayerOuterRadius,            0.99)
  1456. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1457. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  1458. #define        (kPlayerLandChaos,            0.8)
  1459. #define        (kPlayerLandClumps,            1)
  1460. #define        (kPlayerFlatChaos,            0.8)
  1461. #define        (kPlayerFlatClumps,            2)
  1462. #define        (kPlayerTreePercentage,            0.03)
  1463.  
  1464.  
  1465. //////////////////////////////////////////////////////////////////////
  1466. // inner neutral definitions
  1467. #define        (kNeutralInnerRadius,            0.5)
  1468. #define        (kNeutralOuterRadius,            0.5)
  1469. #define        (kNeutralOptimalFactor,            0.7)
  1470. #define        (kNumInnerNeutrals,            Between(6, 6))
  1471. #define        (kInnerNeutralPercentLand,        0.11)
  1472. #define        (kInnerNeutralPercentFlat,        0.9)
  1473. #define        (kInnerNeutralTreePercentage,          0.12)
  1474. #define        (kInnerNeutralLandChaos,        0.9)
  1475. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1476. #define        (kInnerNeutralFlatChaos,        0.8)
  1477. #define        (kInnerNeutralFlatClumps,        1)
  1478.  
  1479.  
  1480. //////////////////////////////////////////////////////////////////////
  1481. // outer neutral definitions
  1482. #define        (kNumOuterNeutrals,            36)
  1483. #define        (kOuterNeutralPercentLand,        0.73)
  1484. #define        (kOuterNeutralPercentFlat,        0.9)
  1485. #define        (kOuterNeutralTreePercentage,          0.07)
  1486. #define        (kOuterNeutralLandChaos,        0.8)
  1487. #define        (kOuterNeutralLandClumps,        2)
  1488. #define        (kOuterNeutralFlatChaos,        0.8)
  1489. #define        (kOuterNeutralFlatClumps,        1)
  1490.  
  1491.  
  1492. //////////////////////////////////////////////////////////////////////
  1493. // resource definitions
  1494. #define        (kMaxResourceElevation,            3)
  1495. #define        (kResourceToEdgeDistance,        3)
  1496. #define        (kResourceToWaterDistance,        3)
  1497.  
  1498. #define        (kAnimalPerPlayer,            0)
  1499. #define        (kAnimalPerNeutral,            0)
  1500.  
  1501. #define        (kBerryPerPlayer,                1)
  1502. #define        (kBerryPerNeutral,            0)
  1503.  
  1504. #define        (kFishPerPlayer,                0)
  1505. #define        (kFishPerNeutral,                80)
  1506.  
  1507. #define        (kGoldPerPlayer,                1)
  1508. #define        (kGoldPerNeutral,                13)
  1509.  
  1510. #define        (kOilPerPlayer,                0)
  1511. #define        (kOilPerNeutral,                0)
  1512.  
  1513. #define        (kSteelPerPlayer,                1)
  1514. #define        (kSteelPerNeutral,            13)
  1515.  
  1516. #define        (kStonePerPlayer,                1)
  1517. #define        (kStonePerNeutral,            7)
  1518.  
  1519. #define        (kTreePerPlayer,                0)
  1520. #define        (kTreePerNeutral,                0)
  1521.  
  1522.  
  1523. //////////////////////////////////////////////////////////////////////
  1524. // forest definitions
  1525. #define        (kForestFreeRadius,            9.0)
  1526. #define        (kForestsPerPlayer,            2)
  1527. #define        (kForestChaosLevel,            0.9)
  1528. #define        (kMaxClumpsPerForest,              2)
  1529.  
  1530.  
  1531. #elif Is16Players
  1532. //////////////////////////////////////////////////////////////////////
  1533. // 16 PLAYERS...
  1534. //////////////////////////////////////////////////////////////////////
  1535.  
  1536. //////////////////////////////////////////////////////////////////////
  1537. // terrain definitions
  1538. #define        (kMinIntElevation,            -10)
  1539. #define        (kMaxIntElevation,            12)
  1540. #define        (kElevationScale,                0.99)
  1541. #define        (kPercentLand,                Between(.92, .92))
  1542. #define        (kWaterBorder,                0)
  1543. #define        (kHeightMapChaos,                Between(10, 30))
  1544.  
  1545. #define        (kMinimumStartPositionToMapEdge    4)
  1546. #define        (kOuterPushFromMapCenter        34)
  1547. #define        (kInnerPushFromMapCenter         0)                                    
  1548.         
  1549. //////////////////////////////////////////////////////////////////////
  1550. // player definitions
  1551. #define        (kMaxAngleBetweenTeamMembers,        19.0)
  1552. #define        (kPlayerInnerRadius,            0.6)
  1553. #define        (kPlayerOuterRadius,            0.99)
  1554. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1555. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  1556. #define        (kPlayerLandChaos,            0.8)
  1557. #define        (kPlayerLandClumps,            1)
  1558. #define        (kPlayerFlatChaos,            0.8)
  1559. #define        (kPlayerFlatClumps,            2)
  1560. #define        (kPlayerTreePercentage,            0.03)
  1561.  
  1562.  
  1563. //////////////////////////////////////////////////////////////////////
  1564. // inner neutral definitions
  1565. #define        (kNeutralInnerRadius,            0.5)
  1566. #define        (kNeutralOuterRadius,            0.5)
  1567. #define        (kNeutralOptimalFactor,            0.7)
  1568. #define        (kNumInnerNeutrals,            Between(6, 6))
  1569. #define        (kInnerNeutralPercentLand,        0.11)
  1570. #define        (kInnerNeutralPercentFlat,        0.9)
  1571. #define        (kInnerNeutralTreePercentage,          0.12)
  1572. #define        (kInnerNeutralLandChaos,        0.9)
  1573. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1574. #define        (kInnerNeutralFlatChaos,        0.8)
  1575. #define        (kInnerNeutralFlatClumps,        1)
  1576.  
  1577.  
  1578. //////////////////////////////////////////////////////////////////////
  1579. // outer neutral definitions
  1580. #define        (kNumOuterNeutrals,            36)
  1581. #define        (kOuterNeutralPercentLand,        0.73)
  1582. #define        (kOuterNeutralPercentFlat,        0.9)
  1583. #define        (kOuterNeutralTreePercentage,          0.07)
  1584. #define        (kOuterNeutralLandChaos,        0.8)
  1585. #define        (kOuterNeutralLandClumps,        2)
  1586. #define        (kOuterNeutralFlatChaos,        0.8)
  1587. #define        (kOuterNeutralFlatClumps,        1)
  1588.  
  1589.  
  1590. //////////////////////////////////////////////////////////////////////
  1591. // resource definitions
  1592. #define        (kMaxResourceElevation,            3)
  1593. #define        (kResourceToEdgeDistance,        3)
  1594. #define        (kResourceToWaterDistance,        3)
  1595.  
  1596. #define        (kAnimalPerPlayer,            0)
  1597. #define        (kAnimalPerNeutral,            0)
  1598.  
  1599. #define        (kBerryPerPlayer,                1)
  1600. #define        (kBerryPerNeutral,            0)
  1601.  
  1602. #define        (kFishPerPlayer,                0)
  1603. #define        (kFishPerNeutral,                80)
  1604.  
  1605. #define        (kGoldPerPlayer,                1)
  1606. #define        (kGoldPerNeutral,                13)
  1607.  
  1608. #define        (kOilPerPlayer,                0)
  1609. #define        (kOilPerNeutral,                0)
  1610.  
  1611. #define        (kSteelPerPlayer,                1)
  1612. #define        (kSteelPerNeutral,            13)
  1613.  
  1614. #define        (kStonePerPlayer,                1)
  1615. #define        (kStonePerNeutral,            7)
  1616.  
  1617. #define        (kTreePerPlayer,                0)
  1618. #define        (kTreePerNeutral,                0)
  1619.  
  1620.  
  1621. //////////////////////////////////////////////////////////////////////
  1622. // forest definitions
  1623. #define        (kForestFreeRadius,            9.0)
  1624. #define        (kForestsPerPlayer,            2)
  1625. #define        (kForestChaosLevel,            0.9)
  1626. #define        (kMaxClumpsPerForest,              2)
  1627.  
  1628.  
  1629. //////////////////////////////////////////////////////////////////////
  1630. // End of if...elif... command
  1631. #endif
  1632.  
  1633.  
  1634. #endif        // NOTDEFINED(MEDITERRANEAN_HUGE_RMV)
  1635.